home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / xmlrpclib.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  31.1 KB  |  1,079 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import re
  5. import string
  6. import time
  7. import operator
  8. from types import *
  9.  
  10. try:
  11.     unicode
  12. except NameError:
  13.     unicode = None
  14.  
  15.  
  16. try:
  17.     import datetime
  18. except ImportError:
  19.     datetime = None
  20.  
  21.  
  22. try:
  23.     _bool_is_builtin = False.__class__.__name__ == 'bool'
  24. except NameError:
  25.     _bool_is_builtin = 0
  26.  
  27.  
  28. def _decode(data, encoding, is8bit = re.compile('[\x80-\xff]').search):
  29.     if unicode and encoding and is8bit(data):
  30.         data = unicode(data, encoding)
  31.     
  32.     return data
  33.  
  34.  
  35. def escape(s, replace = string.replace):
  36.     s = replace(s, '&', '&')
  37.     s = replace(s, '<', '<')
  38.     return replace(s, '>', '>')
  39.  
  40. if unicode:
  41.     
  42.     def _stringify(string):
  43.         
  44.         try:
  45.             return string.encode('ascii')
  46.         except UnicodeError:
  47.             return string
  48.  
  49.  
  50. else:
  51.     
  52.     def _stringify(string):
  53.         return string
  54.  
  55. __version__ = '1.0.1'
  56. MAXINT = 0x7FFFFFFFL
  57. MININT = -0x80000000L
  58. PARSE_ERROR = -32700
  59. SERVER_ERROR = -32600
  60. APPLICATION_ERROR = -32500
  61. SYSTEM_ERROR = -32400
  62. TRANSPORT_ERROR = -32300
  63. NOT_WELLFORMED_ERROR = -32700
  64. UNSUPPORTED_ENCODING = -32701
  65. INVALID_ENCODING_CHAR = -32702
  66. INVALID_XMLRPC = -32600
  67. METHOD_NOT_FOUND = -32601
  68. INVALID_METHOD_PARAMS = -32602
  69. INTERNAL_ERROR = -32603
  70.  
  71. class Error(Exception):
  72.     
  73.     def __str__(self):
  74.         return repr(self)
  75.  
  76.  
  77.  
  78. class ProtocolError(Error):
  79.     
  80.     def __init__(self, url, errcode, errmsg, headers):
  81.         Error.__init__(self)
  82.         self.url = url
  83.         self.errcode = errcode
  84.         self.errmsg = errmsg
  85.         self.headers = headers
  86.  
  87.     
  88.     def __repr__(self):
  89.         return '<ProtocolError for %s: %s %s>' % (self.url, self.errcode, self.errmsg)
  90.  
  91.  
  92.  
  93. class ResponseError(Error):
  94.     pass
  95.  
  96.  
  97. class Fault(Error):
  98.     
  99.     def __init__(self, faultCode, faultString, **extra):
  100.         Error.__init__(self)
  101.         self.faultCode = faultCode
  102.         self.faultString = faultString
  103.  
  104.     
  105.     def __repr__(self):
  106.         return '<Fault %s: %s>' % (self.faultCode, repr(self.faultString))
  107.  
  108.  
  109. if _bool_is_builtin:
  110.     boolean = Boolean = bool
  111.     True = True
  112.     False = False
  113. else:
  114.     
  115.     class Boolean:
  116.         
  117.         def __init__(self, value = 0):
  118.             self.value = operator.truth(value)
  119.  
  120.         
  121.         def encode(self, out):
  122.             out.write('<value><boolean>%d</boolean></value>\n' % self.value)
  123.  
  124.         
  125.         def __cmp__(self, other):
  126.             if isinstance(other, Boolean):
  127.                 other = other.value
  128.             
  129.             return cmp(self.value, other)
  130.  
  131.         
  132.         def __repr__(self):
  133.             if self.value:
  134.                 return '<Boolean True at %x>' % id(self)
  135.             else:
  136.                 return '<Boolean False at %x>' % id(self)
  137.  
  138.         
  139.         def __int__(self):
  140.             return self.value
  141.  
  142.         
  143.         def __nonzero__(self):
  144.             return self.value
  145.  
  146.  
  147.     True = Boolean(1)
  148.     False = Boolean(0)
  149.     
  150.     def boolean(value, _truefalse = (False, True)):
  151.         return _truefalse[operator.truth(value)]
  152.  
  153.  
  154. class DateTime:
  155.     
  156.     def __init__(self, value = 0):
  157.         if not isinstance(value, StringType):
  158.             if datetime and isinstance(value, datetime.datetime):
  159.                 self.value = value.strftime('%Y%m%dT%H:%M:%S')
  160.                 return None
  161.             
  162.             if datetime and isinstance(value, datetime.date):
  163.                 self.value = value.strftime('%Y%m%dT%H:%M:%S')
  164.                 return None
  165.             
  166.             if datetime and isinstance(value, datetime.time):
  167.                 today = datetime.datetime.now().strftime('%Y%m%d')
  168.                 self.value = value.strftime(today + 'T%H:%M:%S')
  169.                 return None
  170.             
  171.             if not isinstance(value, (TupleType, time.struct_time)):
  172.                 if value == 0:
  173.                     value = time.time()
  174.                 
  175.                 value = time.localtime(value)
  176.             
  177.             value = time.strftime('%Y%m%dT%H:%M:%S', value)
  178.         
  179.         self.value = value
  180.  
  181.     
  182.     def __cmp__(self, other):
  183.         if isinstance(other, DateTime):
  184.             other = other.value
  185.         
  186.         return cmp(self.value, other)
  187.  
  188.     
  189.     def __str__(self):
  190.         return self.value
  191.  
  192.     
  193.     def __repr__(self):
  194.         return '<DateTime %s at %x>' % (repr(self.value), id(self))
  195.  
  196.     
  197.     def decode(self, data):
  198.         data = str(data)
  199.         self.value = string.strip(data)
  200.  
  201.     
  202.     def encode(self, out):
  203.         out.write('<value><dateTime.iso8601>')
  204.         out.write(self.value)
  205.         out.write('</dateTime.iso8601></value>\n')
  206.  
  207.  
  208.  
  209. def _datetime(data):
  210.     value = DateTime()
  211.     value.decode(data)
  212.     return value
  213.  
  214.  
  215. def _datetime_type(data):
  216.     t = time.strptime(data, '%Y%m%dT%H:%M:%S')
  217.     return datetime.datetime(*tuple(t)[:6])
  218.  
  219. import base64
  220.  
  221. try:
  222.     import cStringIO as StringIO
  223. except ImportError:
  224.     import StringIO
  225.  
  226.  
  227. class Binary:
  228.     
  229.     def __init__(self, data = None):
  230.         self.data = data
  231.  
  232.     
  233.     def __str__(self):
  234.         if not self.data:
  235.             pass
  236.         return ''
  237.  
  238.     
  239.     def __cmp__(self, other):
  240.         if isinstance(other, Binary):
  241.             other = other.data
  242.         
  243.         return cmp(self.data, other)
  244.  
  245.     
  246.     def decode(self, data):
  247.         self.data = base64.decodestring(data)
  248.  
  249.     
  250.     def encode(self, out):
  251.         out.write('<value><base64>\n')
  252.         base64.encode(StringIO.StringIO(self.data), out)
  253.         out.write('</base64></value>\n')
  254.  
  255.  
  256.  
  257. def _binary(data):
  258.     value = Binary()
  259.     value.decode(data)
  260.     return value
  261.  
  262. WRAPPERS = (DateTime, Binary)
  263. if not _bool_is_builtin:
  264.     WRAPPERS = WRAPPERS + (Boolean,)
  265.  
  266.  
  267. try:
  268.     import _xmlrpclib
  269.     FastParser = _xmlrpclib.Parser
  270.     FastUnmarshaller = _xmlrpclib.Unmarshaller
  271. except (AttributeError, ImportError):
  272.     FastParser = None
  273.     FastUnmarshaller = None
  274.  
  275.  
  276. try:
  277.     import _xmlrpclib
  278.     FastMarshaller = _xmlrpclib.Marshaller
  279. except (AttributeError, ImportError):
  280.     FastMarshaller = None
  281.  
  282.  
  283. try:
  284.     import sgmlop
  285.     if not hasattr(sgmlop, 'XMLParser'):
  286.         raise ImportError
  287. except ImportError:
  288.     SgmlopParser = None
  289.  
  290.  
  291. class SgmlopParser:
  292.     
  293.     def __init__(self, target):
  294.         self.finish_starttag = target.start
  295.         self.finish_endtag = target.end
  296.         self.handle_data = target.data
  297.         self.handle_xml = target.xml
  298.         self.parser = sgmlop.XMLParser()
  299.         self.parser.register(self)
  300.         self.feed = self.parser.feed
  301.         self.entity = {
  302.             'amp': '&',
  303.             'gt': '>',
  304.             'lt': '<',
  305.             'apos': "'",
  306.             'quot': '"' }
  307.  
  308.     
  309.     def close(self):
  310.         
  311.         try:
  312.             self.parser.close()
  313.         finally:
  314.             self.parser = None
  315.             self.feed = None
  316.  
  317.  
  318.     
  319.     def handle_proc(self, tag, attr):
  320.         m = re.search('encoding\\s*=\\s*[\'"]([^"\']+)["\']', attr)
  321.         if m:
  322.             self.handle_xml(m.group(1), 1)
  323.         
  324.  
  325.     
  326.     def handle_entityref(self, entity):
  327.         
  328.         try:
  329.             self.handle_data(self.entity[entity])
  330.         except KeyError:
  331.             self.handle_data('&%s;' % entity)
  332.  
  333.  
  334.  
  335.  
  336. try:
  337.     from xml.parsers import expat
  338.     if not hasattr(expat, 'ParserCreate'):
  339.         raise ImportError
  340. except ImportError:
  341.     ExpatParser = None
  342.  
  343.  
  344. class ExpatParser:
  345.     
  346.     def __init__(self, target):
  347.         self._parser = parser = expat.ParserCreate(None, None)
  348.         self._target = target
  349.         parser.StartElementHandler = target.start
  350.         parser.EndElementHandler = target.end
  351.         parser.CharacterDataHandler = target.data
  352.         encoding = None
  353.         if not parser.returns_unicode:
  354.             encoding = 'utf-8'
  355.         
  356.         target.xml(encoding, None)
  357.  
  358.     
  359.     def feed(self, data):
  360.         self._parser.Parse(data, 0)
  361.  
  362.     
  363.     def close(self):
  364.         self._parser.Parse('', 1)
  365.         del self._target
  366.         del self._parser
  367.  
  368.  
  369.  
  370. class SlowParser:
  371.     
  372.     def __init__(self, target):
  373.         import xmllib
  374.         if xmllib.XMLParser not in SlowParser.__bases__:
  375.             SlowParser.__bases__ = (xmllib.XMLParser,)
  376.         
  377.         self.handle_xml = target.xml
  378.         self.unknown_starttag = target.start
  379.         self.handle_data = target.data
  380.         self.handle_cdata = target.data
  381.         self.unknown_endtag = target.end
  382.         
  383.         try:
  384.             xmllib.XMLParser.__init__(self, accept_utf8 = 1)
  385.         except TypeError:
  386.             xmllib.XMLParser.__init__(self)
  387.  
  388.  
  389.  
  390.  
  391. class Marshaller:
  392.     
  393.     def __init__(self, encoding = None, allow_none = 0):
  394.         self.memo = { }
  395.         self.data = None
  396.         self.encoding = encoding
  397.         self.allow_none = allow_none
  398.  
  399.     dispatch = { }
  400.     
  401.     def dumps(self, values):
  402.         out = []
  403.         write = out.append
  404.         dump = self._Marshaller__dump
  405.         if isinstance(values, Fault):
  406.             write('<fault>\n')
  407.             dump({
  408.                 'faultCode': values.faultCode,
  409.                 'faultString': values.faultString }, write)
  410.             write('</fault>\n')
  411.         else:
  412.             write('<params>\n')
  413.             for v in values:
  414.                 write('<param>\n')
  415.                 dump(v, write)
  416.                 write('</param>\n')
  417.             
  418.             write('</params>\n')
  419.         result = string.join(out, '')
  420.         return result
  421.  
  422.     
  423.     def __dump(self, value, write):
  424.         
  425.         try:
  426.             f = self.dispatch[type(value)]
  427.         except KeyError:
  428.             raise TypeError, 'cannot marshal %s objects' % type(value)
  429.  
  430.         f(self, value, write)
  431.  
  432.     
  433.     def dump_nil(self, value, write):
  434.         if not self.allow_none:
  435.             raise TypeError, 'cannot marshal None unless allow_none is enabled'
  436.         
  437.         write('<value><nil/></value>')
  438.  
  439.     dispatch[NoneType] = dump_nil
  440.     
  441.     def dump_int(self, value, write):
  442.         if value > MAXINT or value < MININT:
  443.             raise OverflowError, 'int exceeds XML-RPC limits'
  444.         
  445.         write('<value><int>')
  446.         write(str(value))
  447.         write('</int></value>\n')
  448.  
  449.     dispatch[IntType] = dump_int
  450.     if _bool_is_builtin:
  451.         
  452.         def dump_bool(self, value, write):
  453.             write('<value><boolean>')
  454.             if not value or '1':
  455.                 pass
  456.             write('0')
  457.             write('</boolean></value>\n')
  458.  
  459.         dispatch[bool] = dump_bool
  460.     
  461.     
  462.     def dump_long(self, value, write):
  463.         if value > MAXINT or value < MININT:
  464.             raise OverflowError, 'long int exceeds XML-RPC limits'
  465.         
  466.         write('<value><int>')
  467.         write(str(int(value)))
  468.         write('</int></value>\n')
  469.  
  470.     dispatch[LongType] = dump_long
  471.     
  472.     def dump_double(self, value, write):
  473.         write('<value><double>')
  474.         write(repr(value))
  475.         write('</double></value>\n')
  476.  
  477.     dispatch[FloatType] = dump_double
  478.     
  479.     def dump_string(self, value, write, escape = escape):
  480.         write('<value><string>')
  481.         write(escape(value))
  482.         write('</string></value>\n')
  483.  
  484.     dispatch[StringType] = dump_string
  485.     if unicode:
  486.         
  487.         def dump_unicode(self, value, write, escape = escape):
  488.             value = value.encode(self.encoding)
  489.             write('<value><string>')
  490.             write(escape(value))
  491.             write('</string></value>\n')
  492.  
  493.         dispatch[UnicodeType] = dump_unicode
  494.     
  495.     
  496.     def dump_array(self, value, write):
  497.         i = id(value)
  498.         if self.memo.has_key(i):
  499.             raise TypeError, 'cannot marshal recursive sequences'
  500.         
  501.         self.memo[i] = None
  502.         dump = self._Marshaller__dump
  503.         write('<value><array><data>\n')
  504.         for v in value:
  505.             dump(v, write)
  506.         
  507.         write('</data></array></value>\n')
  508.         del self.memo[i]
  509.  
  510.     dispatch[TupleType] = dump_array
  511.     dispatch[ListType] = dump_array
  512.     
  513.     def dump_struct(self, value, write, escape = escape):
  514.         i = id(value)
  515.         if self.memo.has_key(i):
  516.             raise TypeError, 'cannot marshal recursive dictionaries'
  517.         
  518.         self.memo[i] = None
  519.         dump = self._Marshaller__dump
  520.         write('<value><struct>\n')
  521.         for k, v in value.items():
  522.             write('<member>\n')
  523.             if type(k) is not StringType:
  524.                 if unicode and type(k) is UnicodeType:
  525.                     k = k.encode(self.encoding)
  526.                 else:
  527.                     raise TypeError, 'dictionary key must be string'
  528.             
  529.             write('<name>%s</name>\n' % escape(k))
  530.             dump(v, write)
  531.             write('</member>\n')
  532.         
  533.         write('</struct></value>\n')
  534.         del self.memo[i]
  535.  
  536.     dispatch[DictType] = dump_struct
  537.     if datetime:
  538.         
  539.         def dump_datetime(self, value, write):
  540.             write('<value><dateTime.iso8601>')
  541.             write(value.strftime('%Y%m%dT%H:%M:%S'))
  542.             write('</dateTime.iso8601></value>\n')
  543.  
  544.         dispatch[datetime.datetime] = dump_datetime
  545.         
  546.         def dump_date(self, value, write):
  547.             write('<value><dateTime.iso8601>')
  548.             write(value.strftime('%Y%m%dT00:00:00'))
  549.             write('</dateTime.iso8601></value>\n')
  550.  
  551.         dispatch[datetime.date] = dump_date
  552.         
  553.         def dump_time(self, value, write):
  554.             write('<value><dateTime.iso8601>')
  555.             write(datetime.datetime.now().date().strftime('%Y%m%dT'))
  556.             write(value.strftime('%H:%M:%S'))
  557.             write('</dateTime.iso8601></value>\n')
  558.  
  559.         dispatch[datetime.time] = dump_time
  560.     
  561.     
  562.     def dump_instance(self, value, write):
  563.         if value.__class__ in WRAPPERS:
  564.             self.write = write
  565.             value.encode(self)
  566.             del self.write
  567.         else:
  568.             self.dump_struct(value.__dict__, write)
  569.  
  570.     dispatch[InstanceType] = dump_instance
  571.  
  572.  
  573. class Unmarshaller:
  574.     
  575.     def __init__(self, use_datetime = 0):
  576.         self._type = None
  577.         self._stack = []
  578.         self._marks = []
  579.         self._data = []
  580.         self._methodname = None
  581.         self._encoding = 'utf-8'
  582.         self.append = self._stack.append
  583.         self._use_datetime = use_datetime
  584.         if use_datetime and not datetime:
  585.             raise ValueError, 'the datetime module is not available'
  586.         
  587.  
  588.     
  589.     def close(self):
  590.         if self._type is None or self._marks:
  591.             raise ResponseError()
  592.         
  593.         if self._type == 'fault':
  594.             raise Fault(**self._stack[0])
  595.         
  596.         return tuple(self._stack)
  597.  
  598.     
  599.     def getmethodname(self):
  600.         return self._methodname
  601.  
  602.     
  603.     def xml(self, encoding, standalone):
  604.         self._encoding = encoding
  605.  
  606.     
  607.     def start(self, tag, attrs):
  608.         if tag == 'array' or tag == 'struct':
  609.             self._marks.append(len(self._stack))
  610.         
  611.         self._data = []
  612.         self._value = tag == 'value'
  613.  
  614.     
  615.     def data(self, text):
  616.         self._data.append(text)
  617.  
  618.     
  619.     def end(self, tag, join = string.join):
  620.         
  621.         try:
  622.             f = self.dispatch[tag]
  623.         except KeyError:
  624.             pass
  625.  
  626.         return f(self, join(self._data, ''))
  627.  
  628.     
  629.     def end_dispatch(self, tag, data):
  630.         
  631.         try:
  632.             f = self.dispatch[tag]
  633.         except KeyError:
  634.             pass
  635.  
  636.         return f(self, data)
  637.  
  638.     dispatch = { }
  639.     
  640.     def end_nil(self, data):
  641.         self.append(None)
  642.         self._value = 0
  643.  
  644.     dispatch['nil'] = end_nil
  645.     
  646.     def end_boolean(self, data):
  647.         if data == '0':
  648.             self.append(False)
  649.         elif data == '1':
  650.             self.append(True)
  651.         else:
  652.             raise TypeError, 'bad boolean value'
  653.         self._value = 0
  654.  
  655.     dispatch['boolean'] = end_boolean
  656.     
  657.     def end_int(self, data):
  658.         self.append(int(data))
  659.         self._value = 0
  660.  
  661.     dispatch['i4'] = end_int
  662.     dispatch['int'] = end_int
  663.     
  664.     def end_double(self, data):
  665.         self.append(float(data))
  666.         self._value = 0
  667.  
  668.     dispatch['double'] = end_double
  669.     
  670.     def end_string(self, data):
  671.         if self._encoding:
  672.             data = _decode(data, self._encoding)
  673.         
  674.         self.append(_stringify(data))
  675.         self._value = 0
  676.  
  677.     dispatch['string'] = end_string
  678.     dispatch['name'] = end_string
  679.     
  680.     def end_array(self, data):
  681.         mark = self._marks.pop()
  682.         self._stack[mark:] = [
  683.             self._stack[mark:]]
  684.         self._value = 0
  685.  
  686.     dispatch['array'] = end_array
  687.     
  688.     def end_struct(self, data):
  689.         mark = self._marks.pop()
  690.         dict = { }
  691.         items = self._stack[mark:]
  692.         for i in range(0, len(items), 2):
  693.             dict[_stringify(items[i])] = items[i + 1]
  694.         
  695.         self._stack[mark:] = [
  696.             dict]
  697.         self._value = 0
  698.  
  699.     dispatch['struct'] = end_struct
  700.     
  701.     def end_base64(self, data):
  702.         value = Binary()
  703.         value.decode(data)
  704.         self.append(value)
  705.         self._value = 0
  706.  
  707.     dispatch['base64'] = end_base64
  708.     
  709.     def end_dateTime(self, data):
  710.         value = DateTime()
  711.         value.decode(data)
  712.         if self._use_datetime:
  713.             value = _datetime_type(data)
  714.         
  715.         self.append(value)
  716.  
  717.     dispatch['dateTime.iso8601'] = end_dateTime
  718.     
  719.     def end_value(self, data):
  720.         if self._value:
  721.             self.end_string(data)
  722.         
  723.  
  724.     dispatch['value'] = end_value
  725.     
  726.     def end_params(self, data):
  727.         self._type = 'params'
  728.  
  729.     dispatch['params'] = end_params
  730.     
  731.     def end_fault(self, data):
  732.         self._type = 'fault'
  733.  
  734.     dispatch['fault'] = end_fault
  735.     
  736.     def end_methodName(self, data):
  737.         if self._encoding:
  738.             data = _decode(data, self._encoding)
  739.         
  740.         self._methodname = data
  741.         self._type = 'methodName'
  742.  
  743.     dispatch['methodName'] = end_methodName
  744.  
  745.  
  746. class _MultiCallMethod:
  747.     
  748.     def __init__(self, call_list, name):
  749.         self._MultiCallMethod__call_list = call_list
  750.         self._MultiCallMethod__name = name
  751.  
  752.     
  753.     def __getattr__(self, name):
  754.         return _MultiCallMethod(self._MultiCallMethod__call_list, '%s.%s' % (self._MultiCallMethod__name, name))
  755.  
  756.     
  757.     def __call__(self, *args):
  758.         self._MultiCallMethod__call_list.append((self._MultiCallMethod__name, args))
  759.  
  760.  
  761.  
  762. class MultiCallIterator:
  763.     
  764.     def __init__(self, results):
  765.         self.results = results
  766.  
  767.     
  768.     def __getitem__(self, i):
  769.         item = self.results[i]
  770.         if type(item) == type({ }):
  771.             raise Fault(item['faultCode'], item['faultString'])
  772.         elif type(item) == type([]):
  773.             return item[0]
  774.         else:
  775.             raise ValueError, 'unexpected type in multicall result'
  776.  
  777.  
  778.  
  779. class MultiCall:
  780.     
  781.     def __init__(self, server):
  782.         self._MultiCall__server = server
  783.         self._MultiCall__call_list = []
  784.  
  785.     
  786.     def __repr__(self):
  787.         return '<MultiCall at %x>' % id(self)
  788.  
  789.     __str__ = __repr__
  790.     
  791.     def __getattr__(self, name):
  792.         return _MultiCallMethod(self._MultiCall__call_list, name)
  793.  
  794.     
  795.     def __call__(self):
  796.         marshalled_list = []
  797.         for name, args in self._MultiCall__call_list:
  798.             marshalled_list.append({
  799.                 'methodName': name,
  800.                 'params': args })
  801.         
  802.         return MultiCallIterator(self._MultiCall__server.system.multicall(marshalled_list))
  803.  
  804.  
  805.  
  806. def getparser(use_datetime = 0):
  807.     if use_datetime and not datetime:
  808.         raise ValueError, 'the datetime module is not available'
  809.     
  810.     if FastParser and FastUnmarshaller:
  811.         if use_datetime:
  812.             mkdatetime = _datetime_type
  813.         else:
  814.             mkdatetime = _datetime
  815.         target = FastUnmarshaller(True, False, _binary, mkdatetime, Fault)
  816.         parser = FastParser(target)
  817.     else:
  818.         target = Unmarshaller(use_datetime = use_datetime)
  819.         if FastParser:
  820.             parser = FastParser(target)
  821.         elif SgmlopParser:
  822.             parser = SgmlopParser(target)
  823.         elif ExpatParser:
  824.             parser = ExpatParser(target)
  825.         else:
  826.             parser = SlowParser(target)
  827.     return (parser, target)
  828.  
  829.  
  830. def dumps(params, methodname = None, methodresponse = None, encoding = None, allow_none = 0):
  831.     if isinstance(params, Fault):
  832.         methodresponse = 1
  833.     elif methodresponse and isinstance(params, TupleType):
  834.         pass
  835.     
  836.     if not encoding:
  837.         encoding = 'utf-8'
  838.     
  839.     if FastMarshaller:
  840.         m = FastMarshaller(encoding)
  841.     else:
  842.         m = Marshaller(encoding, allow_none)
  843.     data = m.dumps(params)
  844.     if encoding != 'utf-8':
  845.         xmlheader = "<?xml version='1.0' encoding='%s'?>\n" % str(encoding)
  846.     else:
  847.         xmlheader = "<?xml version='1.0'?>\n"
  848.     if methodname:
  849.         if not isinstance(methodname, StringType):
  850.             methodname = methodname.encode(encoding)
  851.         
  852.         data = (xmlheader, '<methodCall>\n<methodName>', methodname, '</methodName>\n', data, '</methodCall>\n')
  853.     elif methodresponse:
  854.         data = (xmlheader, '<methodResponse>\n', data, '</methodResponse>\n')
  855.     else:
  856.         return data
  857.     return string.join(data, '')
  858.  
  859.  
  860. def loads(data, use_datetime = 0):
  861.     (p, u) = getparser(use_datetime = use_datetime)
  862.     p.feed(data)
  863.     p.close()
  864.     return (u.close(), u.getmethodname())
  865.  
  866.  
  867. class _Method:
  868.     
  869.     def __init__(self, send, name):
  870.         self._Method__send = send
  871.         self._Method__name = name
  872.  
  873.     
  874.     def __getattr__(self, name):
  875.         return _Method(self._Method__send, '%s.%s' % (self._Method__name, name))
  876.  
  877.     
  878.     def __call__(self, *args):
  879.         return self._Method__send(self._Method__name, args)
  880.  
  881.  
  882.  
  883. class Transport:
  884.     user_agent = 'xmlrpclib.py/%s (by www.pythonware.com)' % __version__
  885.     
  886.     def __init__(self, use_datetime = 0):
  887.         self._use_datetime = use_datetime
  888.  
  889.     
  890.     def request(self, host, handler, request_body, verbose = 0):
  891.         h = self.make_connection(host)
  892.         if verbose:
  893.             h.set_debuglevel(1)
  894.         
  895.         self.send_request(h, handler, request_body)
  896.         self.send_host(h, host)
  897.         self.send_user_agent(h)
  898.         self.send_content(h, request_body)
  899.         (errcode, errmsg, headers) = h.getreply()
  900.         if errcode != 200:
  901.             raise ProtocolError(host + handler, errcode, errmsg, headers)
  902.         
  903.         self.verbose = verbose
  904.         
  905.         try:
  906.             sock = h._conn.sock
  907.         except AttributeError:
  908.             sock = None
  909.  
  910.         return self._parse_response(h.getfile(), sock)
  911.  
  912.     
  913.     def getparser(self):
  914.         return getparser(use_datetime = self._use_datetime)
  915.  
  916.     
  917.     def get_host_info(self, host):
  918.         x509 = { }
  919.         if isinstance(host, TupleType):
  920.             (host, x509) = host
  921.         
  922.         import urllib
  923.         (auth, host) = urllib.splituser(host)
  924.         if auth:
  925.             import base64
  926.             auth = base64.encodestring(urllib.unquote(auth))
  927.             auth = string.join(string.split(auth), '')
  928.             extra_headers = [
  929.                 ('Authorization', 'Basic ' + auth)]
  930.         else:
  931.             extra_headers = None
  932.         return (host, extra_headers, x509)
  933.  
  934.     
  935.     def make_connection(self, host):
  936.         import httplib
  937.         (host, extra_headers, x509) = self.get_host_info(host)
  938.         return httplib.HTTP(host)
  939.  
  940.     
  941.     def send_request(self, connection, handler, request_body):
  942.         connection.putrequest('POST', handler)
  943.  
  944.     
  945.     def send_host(self, connection, host):
  946.         (host, extra_headers, x509) = self.get_host_info(host)
  947.         connection.putheader('Host', host)
  948.         if extra_headers:
  949.             if isinstance(extra_headers, DictType):
  950.                 extra_headers = extra_headers.items()
  951.             
  952.             for key, value in extra_headers:
  953.                 connection.putheader(key, value)
  954.             
  955.         
  956.  
  957.     
  958.     def send_user_agent(self, connection):
  959.         connection.putheader('User-Agent', self.user_agent)
  960.  
  961.     
  962.     def send_content(self, connection, request_body):
  963.         connection.putheader('Content-Type', 'text/xml')
  964.         connection.putheader('Content-Length', str(len(request_body)))
  965.         connection.endheaders()
  966.         if request_body:
  967.             connection.send(request_body)
  968.         
  969.  
  970.     
  971.     def parse_response(self, file):
  972.         return self._parse_response(file, None)
  973.  
  974.     
  975.     def _parse_response(self, file, sock):
  976.         (p, u) = self.getparser()
  977.         while sock:
  978.             response = sock.recv(1024)
  979.         response = file.read(1024)
  980.         if not response:
  981.             break
  982.         
  983.         if self.verbose:
  984.             print 'body:', repr(response)
  985.         
  986.         p.feed(response)
  987.         continue
  988.         file.close()
  989.         p.close()
  990.         return u.close()
  991.  
  992.  
  993.  
  994. class SafeTransport(Transport):
  995.     
  996.     def make_connection(self, host):
  997.         import httplib
  998.         (host, extra_headers, x509) = self.get_host_info(host)
  999.         
  1000.         try:
  1001.             HTTPS = httplib.HTTPS
  1002.         except AttributeError:
  1003.             raise NotImplementedError("your version of httplib doesn't support HTTPS")
  1004.  
  1005.         if not x509:
  1006.             pass
  1007.         return HTTPS(host, None, **{ })
  1008.  
  1009.  
  1010.  
  1011. class ServerProxy:
  1012.     
  1013.     def __init__(self, uri, transport = None, encoding = None, verbose = 0, allow_none = 0, use_datetime = 0):
  1014.         import urllib
  1015.         (type, uri) = urllib.splittype(uri)
  1016.         if type not in ('http', 'https'):
  1017.             raise IOError, 'unsupported XML-RPC protocol'
  1018.         
  1019.         (self._ServerProxy__host, self._ServerProxy__handler) = urllib.splithost(uri)
  1020.         if not self._ServerProxy__handler:
  1021.             self._ServerProxy__handler = '/RPC2'
  1022.         
  1023.         if transport is None:
  1024.             if type == 'https':
  1025.                 transport = SafeTransport(use_datetime = use_datetime)
  1026.             else:
  1027.                 transport = Transport(use_datetime = use_datetime)
  1028.         
  1029.         self._ServerProxy__transport = transport
  1030.         self._ServerProxy__encoding = encoding
  1031.         self._ServerProxy__verbose = verbose
  1032.         self._ServerProxy__allow_none = allow_none
  1033.  
  1034.     
  1035.     def __request(self, methodname, params):
  1036.         request = dumps(params, methodname, encoding = self._ServerProxy__encoding, allow_none = self._ServerProxy__allow_none)
  1037.         response = self._ServerProxy__transport.request(self._ServerProxy__host, self._ServerProxy__handler, request, verbose = self._ServerProxy__verbose)
  1038.         if len(response) == 1:
  1039.             response = response[0]
  1040.         
  1041.         return response
  1042.  
  1043.     
  1044.     def __repr__(self):
  1045.         return '<ServerProxy for %s%s>' % (self._ServerProxy__host, self._ServerProxy__handler)
  1046.  
  1047.     __str__ = __repr__
  1048.     
  1049.     def __getattr__(self, name):
  1050.         return _Method(self._ServerProxy__request, name)
  1051.  
  1052.  
  1053. Server = ServerProxy
  1054. if __name__ == '__main__':
  1055.     server = ServerProxy('http://time.xmlrpc.com/RPC2')
  1056.     print server
  1057.     
  1058.     try:
  1059.         print server.currentTime.getCurrentTime()
  1060.     except Error:
  1061.         v = None
  1062.         print 'ERROR', v
  1063.  
  1064.     multi = MultiCall(server)
  1065.     multi.currentTime.getCurrentTime()
  1066.     multi.currentTime.getCurrentTime()
  1067.     
  1068.     try:
  1069.         for response in multi():
  1070.             print response
  1071.     except Error:
  1072.         v = None
  1073.         print 'ERROR', v
  1074.     except:
  1075.         None<EXCEPTION MATCH>Error
  1076.     
  1077.  
  1078. None<EXCEPTION MATCH>Error
  1079.